Please address the comments from this code review:

## Overall Comments
- The combination of `_is_underlying_client_closed()` and `_ensure_client()` runs on every request and will log a warning and recreate the client on every call if the SDK internals change (raising `AttributeError`); consider caching a boolean flag when detection fails so you only log once and avoid repeated costly client recreation attempts.
- Client recreation in `_ensure_client()` is not synchronized, so in high-concurrency scenarios multiple coroutines could simultaneously see a closed client and race to create new instances and update `self.default_params`; consider adding a simple async lock around the recreation path to make this thread-safe.

## Individual Comments

### Comment 1
<location path="astrbot/core/provider/sources/openai_source.py" line_range="501-510" />
<code_context>
+    def _is_underlying_client_closed(self) -> bool:
</code_context>
<issue_to_address>
**issue (bug_risk):** Treating AttributeError as "client is closed" may cause endless client recreation and log spam if the SDK internals change.

In `_is_underlying_client_closed`, an `AttributeError` currently logs a warning and returns `True`, causing `_ensure_client` to recreate the client on every call if `_client` or `is_closed` is ever removed/renamed. Consider instead returning `False` on `AttributeError` (treat as "unknown / assume open"), or at least gating the warning and recreation behind a one-time flag to avoid repeated reconstruction and log noise in that scenario.
</issue_to_address>

### Comment 2
<location path="astrbot/core/provider/sources/openai_source.py" line_range="462-464" />
<code_context>
                 self.custom_headers[key] = str(self.custom_headers[key])

-        if "api_version" in provider_config:
+        self.client = self._create_openai_client()
+
+        self.default_params = inspect.signature(
+            self.client.chat.completions.create,
+        ).parameters.keys()
</code_context>
<issue_to_address>
**suggestion:** The `default_params` initialization logic is duplicated and could be centralized.

The logic that sets `self.default_params` from `inspect.signature(self.client.chat.completions.create)` now lives in both `__init__` and `_ensure_client`. To avoid divergence when this logic changes, extract it into a helper (e.g., `_refresh_default_params()`) and call that from both places.

Suggested implementation:

```python
        self.client = self._create_openai_client()

        self._refresh_default_params()

        model = provider_config.get("model", "unknown")
        self.set_model(model)

```

```python
    def _refresh_default_params(self) -> None:
        """
        Refresh default_params based on the current OpenAI client.

        This centralizes the logic for inspecting the chat.completions.create
        signature so it can be reused from __init__ and any place the client
        is (re)initialized.
        """
        if self.client is None:
            self.default_params = ()
            return

        self.default_params = inspect.signature(
            self.client.chat.completions.create,
        ).parameters.keys()

    def _create_http_client(self, provider_config: dict) -> httpx.AsyncClient | None:
        """创建带代理的 HTTP 客户端"""
        proxy = provider_config.get("proxy", "")

```

You should also update `_ensure_client` (or any other place that recreates `self.client`) to call `self._refresh_default_params()` instead of duplicating the `inspect.signature(self.client.chat.completions.create)` logic. Specifically:
1. After any assignment to `self.client = ...` inside `_ensure_client`, add `self._refresh_default_params()`.
2. Remove any direct `self.default_params = inspect.signature(...).parameters.keys()` code from `_ensure_client`.
</issue_to_address>

### Comment 3
<location path="astrbot/core/provider/sources/openai_source.py" line_range="525" />
<code_context>
+            )
+            return True
+
+    def _ensure_client(self) -> None:
+        """确保 client 可用。如果 client 为 None 或底层连接已关闭，则重新创建。"""
+        if self.client is None or self._is_underlying_client_closed():
</code_context>
<issue_to_address>
**issue (complexity):** Consider introducing a unified `_ensure_client_with_key` helper to manage client creation and key binding so that call sites and `get_current_key` stay simple and side‑effect free.

You can reduce complexity around client/key lifecycle by centralizing “ensure client + key” and avoiding side‑effectful `get_current_key`:

```python
def _ensure_client_with_key(self, api_key: str | None = None) -> None:
    """Ensure client exists and is bound to the given key (if provided)."""
    if api_key is not None and api_key != self.chosen_api_key:
        self.chosen_api_key = api_key

    # Reuse your existing logic for closed/None detection
    if self.client is None or self._is_underlying_client_closed():
        self.client = self._create_openai_client()
        self.default_params = inspect.signature(
            self.client.chat.completions.create,
        ).parameters.keys()
    elif api_key is not None:
        # Keep ability to rotate keys on an existing client
        self.client.api_key = api_key
```

Then the callers become simpler and consistent:

```python
# text_chat
for retry_cnt in range(max_retries):
    try:
        self._ensure_client_with_key(chosen_key)
        llm_response = await self._query(payloads, func_tool)
        break
    ...

# text_chat_stream
for retry_cnt in range(max_retries):
    try:
        self._ensure_client_with_key(chosen_key)
        async for response in self._query_stream(payloads, func_tool):
            yield response
        break
    ...

# set_key
def set_key(self, key) -> None:
    self._ensure_client_with_key(key)

# get_current_key
def get_current_key(self) -> str:
    # Avoids creating/recreating a client as a side effect
    return self.chosen_api_key
```

This keeps all current behavior (client recreation on closed/None, key rotation on retries) but:

- Removes repeated `self._ensure_client()` + `self.chosen_api_key = ...` + `self.client.api_key = ...` blocks.
- Makes the “which key is bound to which client” rule explicit in a single place.
- Prevents `get_current_key` from unexpectedly constructing or recreating a client.
</issue_to_address>